Method and system for attribute management in a namespace

ABSTRACT

A computer-based method and system for managing attributes of objects in a namespace and for allowing multiple views into the namespace. The namespace system allows the objects identified by the names of the namespace to be hierarchically organized. The namespace system allows for attributes of various objects, including directory objects and data objects, to be dynamically defined after creation of an object. The namespace system also allows for the querying of objects based on their dynamically defined attributes. When the namespace system receives a query specification that includes a newly defined attribute, it identifies the objects that match that query specification that includes a newly defined attribute, it identifies the objects that match that query specification.

PRIORITY CLAIM

This application is a continuation of U.S. application Ser. No.11/933,068 filed Oct. 31, 2007, titled “Method and System for AttributeManagement in a Namespace”, for all purposes including but not limitedto the right of priority and benefit of earlier filing date, andexpressly incorporates by reference the entire content of patentapplication Ser. No. 11/933,068 for all purposes. U.S. patentapplication Ser. No. 11/933,068 is a continuation of U.S. patentapplication Ser. No. 11/589,397 (now U.S. Pat. No. 7,778,966) filed Aug.9, 2006, titled “Method and System for Attribute Management in aNamespace”. U.S. patent application Ser. No. 11/589,397 is acontinuation of U.S. patent application Ser. No. 10/323,874 filed Dec.18, 2002, titled “Method and System for Attribute Management in aNamespace”, which claims the benefit of U.S. Provisional Application No.60/341,932 filed Dec. 18, 2001. This application claims the benefit ofthe following applications for all purposes including but not limited tothe right of priority and benefit of earlier filing date, and expresslyincorporates by reference the entire content of the followingapplications for all purposes: U.S. patent application Ser. No.11/933,068; U.S. patent application Ser. No. 11/589,397; U.S. patentapplication Ser. No. 10/323,874; and U.S. patent application Ser. No.60/341,932.

TECHNICAL FIELD OF THE INVENTION

The described technology relates generally to namespaces andparticularly to managing of attributes for objects within a namespace.

BACKGROUND OF THE INVENTION

The following application is incorporated by reference as if fully setforth herein: U.S. application Ser. No. 11/589,397 filed Aug. 9, 2006.

A namespace is a collection of names that each uniquely identifies anobject. For example, the pathnames of a conventional file systemuniquely identify the files of the file system and are thus a namespacefor the file system. Namespaces, however, can contain the names of awide variety of objects including files, computer input and outputdevices, users, and so on. A namespace service typically providesvarious functions through which applications and users can access theinformation of the namespace. For example, a namespace may provide afunction to retrieve a reference to an object having a specified name.When the function is invoked, it accesses various data structures tolocate the object and return its reference.

The difficulty with namespaces is that they typically have predefinedattributes associated with their objects. As such, applications andapplication developers are constrained by the attributes defined by thenamespace developers. In addition, namespaces typically provide alogical view of their objects that corresponds to the physicalorganization of the namespace. For example, if the namespace ishierarchically organized, then the only view of that namespace reflectsthat same hierarchical organization. It would be desirable to have anamespace service that would allow for more flexible handling ofattributes and would allow for more flexible views into the namespace.

BRIEF DESCRIPTION OF THE DRAWINGS

Preferred and alternative embodiments of the present invention aredescribed in detail below with reference to the following drawings:

FIG. 1 is a block diagram illustrating components of the namespacesystem in one embodiment.

FIG. 2 lists methods of the namespace interface in one embodiment.

FIG. 3 is a flow diagram illustrating the processing of a set method ofthe namespace interface in one embodiment.

FIG. 4 is a flow diagram illustrating processing of the get method ofthe namespace interface in one embodiment.

FIG. 5 is a flow diagram illustrating the processing of a set attributemethod of the namespace interface in one embodiment.

FIG. 6 is a flow diagram illustrating the processing of a query methodof the namespace interface in one embodiment.

FIG. 7 is a block diagram illustrating a definition of a viewspecification in one embodiment.

FIG. 8 is a block diagram illustrating a view generated by the viewspecification of FIG. 7 in one embodiment.

FIG. 9 is a flow diagram illustrating the processing of a filter methodof the namespace in interface in one embodiment.

FIG. 10 is a flow diagram illustrating the process of the create viewnamespace function in one embodiment.

FIG. 11 is a block diagram illustrating the synchronization of aduplicate namespace with its original namespace in one embodiment.

FIG. 12 is a block diagram illustrating the caching of attributes orother metadata in one embodiment.

FIG. 13 is a flow diagram illustrating processing of the get attributemethod of the proxy object in one embodiment.

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT

A computer-based method and system for managing attributes of objects ina namespace and for allowing multiple views into the namespace isprovided. In one embodiment, the namespace system allows the objectsidentified by the names of the namespace to be hierarchically organized.One skilled in the art would appreciate that the namespace of thenamespace system need not be hierarchical. For example, the namespacecould be flat. The namespace system allows for attributes of variousobjects, including directory objects and data objects, to be dynamicallydefined after creation of an object. For example, an object representinga video may have the predefined attributes of format type and length.The namespace system allows for an additional attribute, such as title,to be dynamically added to the object. The namespace system may define anamespace interface (e.g., a collection of methods or functions) thateach object identified by the namespace implements. The namespaceinterface may include a function for defining new attributes and settingthe values of those attributes. The namespace system also allows for thequerying of objects based on their dynamically defined attributes. Whenthe namespace system receives a query specification that includes anewly defined attribute, it identifies the objects that match that queryspecification. In this way, the namespace system allows for flexiblecustomization of the information or metadata associated with the objectsof a namespace.

In another embodiment, the namespace system generates different views ofportions of a namespace based on a query specification and a viewspecification. The query specification specifies the criteria for theobjects that are to be included in the view. The query specification mayuse any conventional querying language, such as an SQL-type language.The query specification may specify attribute names and the values forthe objects that match the query specification. The view specificationspecifies how the objects that match the query specification are to beorganized when they are returned. The objects may be organizedhierarchically based on values of certain attributes. For example, aquery specification may indicate to retrieve objects whose data type is“video.” The view specification may specify to organize those objectshierarchically by their genre and then by the director within eachgenre. The genre and director may be attributes of the video objects. Insuch a case, the view specification may be “genre/director.” Moregenerally, the view specification may specify a hierarchy of attributenames and attribute values defining the organization of the objects.

In another embodiment, the namespace system allows for caching ofattribute names and values so that objects that are stored remotely canhave their attributes accessed without the need to access the remotestorage each time. When an attribute of an object is initially accessed,the namespace system accesses the remote storage to retrieve theattributes (e.g., metadata) of the object. The namespace system thenstores the attribute names and values locally. When the attributes arenext accessed, the namespace system need only access the local storage.By caching the attribute names and values, the namespace system canreduce the number of remote accesses.

In another embodiment, the namespace system allows for the duplicationof objects so that they can be accessed when a computer system isoff-line. For example, a user may want to store a duplicate portion ofthe namespace relating to customer addresses on a personal digitalassistant (“PDA”). The namespace system allows the user to specify aquery specification and a view specification for the duplicate portionof the namespace. The namespace system then identifies the objects thatmatch that query specification, generates a hierarchical organization ofthose objects using the view specification, and makes a copy of thathierarchical organization as a duplicated namespace for use off-line.After the duplicate namespace is created, a user may change the objectsof either the duplicate or original namespace. In such case, thenamespace may be out of synchronization. Eventually, the user may wantto synchronize the namespaces. To synchronize the namespaces, thenamespace system may rerun the query specification against the originalnamespace, as modified. The namespace system may then compare theobjects returned by the query to the objects of the duplicate namespace.The namespace system can then resolve any differences by updating theoriginal namespace or the duplicate namespace as appropriate.

FIG. 1 is a block diagram illustrating components of the namespacesystem in one embodiment. The computer system 110 is connected tocomputer system 120 and computer system 130 via communications link 140.Computer system 110 includes the root of the namespace 111, a namespaceinterface 112, and an application program 113. Namespace 111 may includedirectory objects and data objects. The directory objects specify thehierarchical organization of the namespace, and the data objectscorrespond to the leaf nodes or data identified by the namespace of thenamespace. In this example, the namespace 111 includes a reference tonamespace 121 defined on computer system 120. In particular, namespace111 contains the reference “NS1,” which identifies the namespace 121.Namespace 121 is thus a sub-namespace of namespace 111. Namespace 121includes a reference to namespace 131 of computer system 130. Namespaces111, 121, and 131 form a distributed namespace. The namespace interfaces112, 122, and 132 provide various functions associated with each object,directory or data, of the namespace. As the objects of the namespace areaccessed, in-memory objects may be instantiated to represent eachnamespace object. Each in-memory objects may implement a namespaceinterface that provides methods or functions for accessing the object.Wrappers implementing the namespace interface may be used to encapsulatein-memory objects, file system objects, database objects, devices, andso on that are part of the namespace.

The computer systems and servers of the namespace system may include acentral processing unit, memory, input devices (e.g., keyboard andpointing devices), output devices (e.g., display devices), and storagedevices (e.g., disk drives). The memory and storage devices arecomputer-readable media that may contain instructions that implement thenamespace system. In addition, the data structures and messagestructures may be stored or transmitted via a data transmission medium,such as a signal on a communications link. Various communications linksmay be used, such as the Internet, a local area network, a wide areanetwork, or a point-to-point dial-up connection.

FIG. 2 lists methods of the namespace interface in one embodiment. Thenamespace interface defines a set method for adding objects, directoryor data, to the namespace. The set method is passed a unique name forthe object along with a reference to the object, which may be areference to the namespace interface of the object. The name of anobject may be represented as a hierarchical pathname similar to pathnames used for files, any of which may be relative to this object. Theterm “this object” refers to the object for which the method is invoked.The set method can be used to add a sub-namespace to another namespace,such as adding sub-namespace 121 to namespace 111. The namespaceinterface includes a get method for retrieving a reference to an objectof a specified name. The namespace interface includes a get childrenmethod that returns a list of the names of the child objects of thisobject. The namespace interface includes a set attribute method which ispassed an attribute name and value. The method sets the attribute withthat name to that value. If no attribute with that name exists for thisobject, then the method creates a new attribute with that name and setsits value. The attribute name for an object may be hierarchicallyorganized. The namespace interface includes a get attribute method thatretrieves the value of the named attribute. The namespace interfaceincludes a get attributes method that retrieves a list of the names ofthe attributes of the object. The namespace interface includes a querymethod that is passed a query specification and returns a list ofobjects of the namespace rooted at this object that match the queryspecification. The namespace interface includes a filter method that ispassed a query specification and a view specification and returns areference to an object that is the root of a view namespace thatrepresents that query and view. The namespace interface includes a getinterfaces method that retrieves a list of interfaces implemented bythis object. The namespace interface includes a get data object thatreturns the data (e.g., video) associated with this object.

FIG. 3 is a flow diagram illustrating the processing of a set method ofthe namespace interface in one embodiment. The set method is passed thename of an object relative to this object and is passed the new objectto be added to the namespace. In block 301, the method selects the firstname of the passed name. If the name is specified as a sequence of namesseparated by slashes, then the method retrieves the name before thefirst slash. In decision block 302, if there is only one name in thepassed name, then the method is at the place in the namespace at whichto add the object and continues at block 303, else the method continuesat block 304. In block 303, the method adds the new object as a child ofthis object and then returns. In block 304, the method retrieves a listof the names of the child objects of this object. In blocks 305-307, themethod loops searching for a child object whose name matches the firstname. In block 305, the method selects the next child name. In decisionblock 306, if all the child names have already been selected, then themethod adds a new directory to create a path for the new object andcontinues at block 309, else the method continues at block 307. Indecision block 307, if the name of the child object matches the firstname, then the method continues at block 308, else the method loops toblock 305 to select the next child name. In block 308, the methodinvokes the set method of the child object passing the rest of the name(excepting the first name) and passing the new object. The method thenreturns. In block 309, the method creates a new directory object. Inblock 310, the method adds the new directory object as a child of thisobject specifying that its name is the first name. In block 311, themethod invokes the set method of the directory objects passing the restof the name along with the new object and then returns.

FIG. 4 is a flow diagram illustrating processing of a get method of thenamespace interface in one embodiment. The get method is passed the nameof an object relative to this object and returns a reference to thatnamed object. In block 401, the method selects the first name of thepassed name. In decision block 402, if there are no more names in thepassed name, then the method has found the object and returns thisobject, else the method continues at block 403. In block 403, the methodinvokes the get children method of this object to retrieve the names ofthe child objects. In block 404-406, the method loops searching for thechild object with the name that matches the first name. In block 404,the method selects the next name of a child object. In decision block405, if all the names have already been selected, then the methodreturns an error because no object of that name has been found, else themethod continues at block 406. In decision block 406, if the selectedchild matches the first name, then the method continues at block 407,else the method loops to block 404 to select the next child name. Inblock 407, the method invokes the get method of the child object passingthe rest of the name and receiving a reference to the object in return.The method then returns the object.

FIG. 5 is a flow diagram illustrating the processing of a set attributemethod of the namespace interface in one embodiment. The set attributemethod is passed the name of an attribute and its value. In blocks501-503, the method searches for an attribute of this object with thepassed name. In block 504, the method selects the next attribute. Indecision block 502, if all the attributes have already been selected,then the method continues at block 506, else the method continues atblock 503. In decision block 503, if the name of the selected attributeequals the passed name, then the method continues at block 504, else themethod loops to block 501 to select the next attribute. In block 504,the method sets the value of the selected attribute to the passed nameand then returns. In block 506, the method defines a new attribute withthe passed name for this object. In block 507, the method sets the valueof the new attribute to the passed value and then returns.

FIG. 6 is a flow diagram illustrating the processing of a query methodof the namespace interface in one embodiment. The query method is passeda query specification (or criteria) and returns a list of objectreferences that match the query specification. This object is the rootof the namespace that is searched. In decision block 601, if theattributes of this object match the query specification, then the methodcontinues at block 602, else the method continues at block 603. In block602, the method adds a reference to this object to the object list andcontinues at block 603. In an alternate embodiment, the method only addsdata objects or leaf objects to the object list. In block 603, themethod selects the next child object of this object. In decision block604, if all the child objects have already been selected, then themethod returns, else the method continues at block 605. In block 605,the method invokes the query method of the selected child object passingthe query specification and the object list. The method then loops toblock 603 to select the next child object.

FIG. 7 is a block diagram illustrating a definition of a viewspecification in one embodiment. In this example, view specification 700includes a root node 701 that has child nodes 702 and 705. Child node705 has child nodes 703 and 704. Node 705 has child node 706. Node 702indicates that all objects whose media attribute has a value of “photos”are to be organized in one branch of the view. Those objects are furtherto be organized based on the kids attribute (e.g., kids shown in eachphoto) and location attribute (e.g., location of a vacation). Node 705indicates that the objects with a value of “music” for their mediaattributes are to be organized down a separate branch of the viewnamespace. Node 706 indicates that the music objects are to be furtherorganized according to their artist. One skilled in the art willappreciate that views can be specified in various different ways and tobe arbitrarily complex.

FIG. 8 is a block diagram illustrating a view generated by the viewspecification of FIG. 7 in one embodiment. View 100 includes rootdirectory object 801. Child object 802 identifies the objects whosemedia type equals “photos.” Directory objects 803, 805, and 806 organizethe objects according to the kids in the photos. Directory objects 804,807, and 808 organize the objects according to location of vacation. Asillustrated by the leaf objects, various objects can be accessed viamultiple paths of the view hierarchy. For example, leaf object 809 canbe accessed via path “photos/kids/Ben” and via path“photos/vacation/Mexico.”.

FIG. 9 is a flow diagram illustrating the processing of a filter methodof the namespace in interface in one embodiment. The filter method ispassed a query specification and a view specification and returns theroot object of the view. In block 901, the method invokes the querymethod of this object passing the query specification and receiving anobject list of the objects that match that query specification. In block902, the method creates a root object for the view. In block 903, themethod invokes the create view namespace function to create the view andthen returns the root object of the view.

FIG. 10 is a flow diagram illustrating the processing of the create viewnamespace function in one embodiment. The function is passed a parentobject for the namespace, a view specification, and an object list. Thefunction creates a view namespace rooted at the parent object using theview specification and objects in the object list. In this example, theview specification is a simple path of attribute names that indicate theattributes for each level of the view namespace hierarchy. In decisionblock 1001, if all the attributes have already been processed, then thefunction is ready to add the objects of the object list to the viewnamespace as child objects of the parent object and continues at block1008, else the function continues at block and 1002. In block 1002, thefunction identifies the range of values for the next attribute in theview specification. For example, the range of values for the kidsattribute of FIG. 8 are “Ben” and “Scott.” In blocks 1003-1007, thefunction loops creating directory objects for the ranges and creatingthe view namespaces for those objects. In block 1003, the functionselects the next range of values. In decision block 1004, if all theranges of values have already been selected, then the function returns,else the function continues at block 1005. In block 1005, the functioncreates a directory object for the selected range of values. In block1006, the function invokes the set method of the parent object passingthe created directory object along with the name representing theselected range of values. In block 1007, the function recursivelyinvokes the create view namespace function passing the directory objectas the parent object, the remainder of the view specification, and alist of objects that match the selected range. The function then loopsto block 1003 to select the next range of values. In block 1008, thefunction selects the next object in the object list. In decision block1009, if all the objects have already been selected, then the functionreturns, else the function continues at block 1010. In block 1010, thefunction invokes the set method of the parent object passing the namefor the selected object along with a reference to the selected objectand then loops to block 1008 to select the next object of the objectlist.

FIG. 11 is a block diagram illustrating the synchronization of aduplicate namespace with its original namespace in one embodiment. Thesynchronize method may be a method of the namespace interface or may bea method provided by a synchronization interface of the root object ofthe duplicate namespace object. The method is passed the originalnamespace. In block 1101, the method retrieves the view specificationfor this duplicate namespace. In block 1102, the method invokes thequery method of the root object of the original namespace passing thequery specification and receiving a list of objects that match thatquery specification in return. In block 1103, the method identifies thedifferences in the objects of the returned object list and the objectsof the duplicate namespace. One skilled in the art will appreciate thatstandard diff algorithms can be used to identify the differences. Inblock 1104, the method resolves the differences in the object list. Theresolution depends on how the duplicate namespace is to be synchronizedwith the original namespace. If the duplicate namespace is a read-onlycopy of the original namespace, then any changes made to the originalnamespace need to be reflected in the duplicate namespace. These changescan be reflected by regenerating the duplicate namespace or simplymaking changes to the duplicate namespace to reflect the differences. Inblock 1105, the method retrieves the view for this duplicate namespace.In block 1106, the method deletes child objects of this root object toinitialize the duplicate namespace. In block 1106, the method invokesthe create view namespace function passing this object as the rootobject, the view specification, and the object list. That functioncreates the namespace under this object. The method then returns.

FIG. 12 is a block diagram illustrating the caching of attributes orother metadata in one embodiment. Computer system 1210 is an objectserver, such as a video server, that contains data objects of thenamespace. The data objects may be physically stored using index 1211,data table 1212, and attribute table 1213. Client computer system 1220has application program 1212 that accesses the objects of the objectserver. The application accesses the objects via proxy object 1221,which is an implementation of the namespace interface. When a method ofthe proxy object is invoked, the method marshals the parameters andforwards them to the object server. The object server performs thefunction of the method and then returns any parameters to the proxyobject, which are then returned to the application program. The proxyobject in one embodiment retrieves attributes associated with the dataobjects and stores them in cache 1223. When the application subsequentlyinvokes a method of the proxy object that relies on attribute data(e.g., the get attribute method), the proxy object can retrieve theappropriate information from the attribute cache and return it directlyto the application program without having to access the object server.

FIG. 13 is a flow diagram illustrating processing of the get attributemethod of the proxy object in one embodiment. The get attribute methodis passed the name of the attribute and returns its value. In block1301, the method checks the cache for an attribute of that nameassociated with this object. One skilled in the art will appreciate thatthere may be a proxy object for each object in the namespace. Indecision block 1302, if the attributes are found for this object in thecache, then the method continues its normal processing to retrieve theattribute value, else the method continues at block 1303. In block 1303,the method sends a request to the object server for the attributes ofthis object. In block 1304, the method receives the attributes from theobject server. In block 1305, the method caches the attributes andcontinues its normal processing to retrieve the attribute valuesindicated by the ellipses.

One skilled in the art will appreciate that although specificembodiments of the namespace system have been described herein forpurposes of illustration, various modifications may be made withoutdeviating from the spirit and scope of the invention. Accordingly, theinvention is not limited except by the appended claims.

1-4. (canceled)
 5. A system, comprising: one or more processors; and oneor more memories having program instructions stored thereon that areexecutable by the one or more processors to cause the system to performoperations comprising: storing information that implements a namespacehaving a plurality of objects, wherein the stored information includesdata for various ones of the plurality of objects that is indicative ofattribute values for one or more of a plurality of attributes of theplurality of objects; receiving an object that is specified as having aparticular attribute value for a user-defined attribute, wherein theuser-defined attribute is not currently included in the namespace;adding the user-defined attribute to the namespace; adding the receivedobject to the namespace; and transmitting, in response to receiving aquery that specifies the particular attribute value, information usableto access one or more objects in the namespace, including the addedobject.
 6. The system of claim 5, wherein the user-defined attribute isone of: location, media type, style, individual, genre, director, orartist.
 7. The system of claim 5, wherein the user-defined attribute isa location attribute and wherein the particular attribute valuespecifies a particular location.
 8. The system of claim 5, wherein theuser-defined attribute is a media type attribute and wherein theparticular attribute value specifies at least one of: photo, audio, orvideo.
 9. The system of claim 5, further comprising: receiving a seconduser-defined attribute; and assigning one or more second attributevalues for the second user-defined attribute to one or more objects inthe namespace.
 10. The system of claim 5, further comprising: assigninga second attribute value for the user-defined attribute to a secondobject in the namespace, wherein the second attribute value is adifferent attribute value than the particular attribute value.
 11. Thesystem of claim 5, further comprising: caching information indicating aset of attributes assigned to the added object; in response todetermining that the query specifies an attribute value for theuser-defined attribute, determining, based on the cached information,whether the user-defined attribute is assigned to the added object; andproceeding to determine whether the added object has the particularattribute value in response to determining that the user-definedattribute is assigned to the added object.
 12. The system of claim 5,further comprising: synchronizing a second namespace at anothercomputing system to include the user-defined attribute, wherein thesecond namespace was previously copied from the namespace.
 13. Thesystem of claim 5, wherein the query indicates an organization of queryresults including a hierarchy of attributes; and wherein the informationusable to access one or more objects in the namespace is organized usingthe hierarchy of attributes, wherein the user-defined attribute is in aposition in the hierarchy of attributes that is indicated by the query.14. A non-transitory computer-readable medium having instructions storedthereon that are executable by a computing device to perform operationscomprising: storing information that implements a namespace having aplurality of objects, wherein the stored information includes data forvarious ones of the plurality of objects that is indicative of attributevalues for one or more of a plurality of attributes of the plurality ofobjects; receiving a user-defined attribute for the namespace and aparticular attribute value for the user-defined attribute for an objectincluded in the namespace; adding the user-defined attribute to thenamespace; assigning the particular attribute value to an object in thenamespace; and in response to receiving a query that specifies theparticular attribute value, transmitting information usable to accessone or more objects in the namespace, including the object.
 15. Thenon-transitory computer-readable medium of claim 14, wherein theuser-defined attribute is an identity attribute and wherein theparticular attribute value indicates the identity of an individualrepresented within content of the object.
 16. The non-transitorycomputer-readable medium of claim 14, wherein the operations furthercomprise: receiving a second user-defined attribute for the namespace;and assigning one or more second attribute values for the seconduser-defined attribute to one or more objects in the namespace.
 17. Thenon-transitory computer-readable medium of claim 14, wherein theoperations further comprise: assigning a second attribute value for theuser-defined attribute to a second object in the namespace, wherein thesecond attribute value is a different attribute value than theparticular attribute value.
 18. The non-transitory computer-readablemedium of claim 14, further comprising: synchronizing a copy of thenamespace to include the user-defined attribute, wherein the copy of thenamespace is maintained by another computing system.
 19. A system,comprising: one or more processors; and one or more memories havingprogram instructions stored thereon that are executable by the one ormore processors to cause the system to perform operations comprising:storing information that implements a namespace having a plurality ofobjects, wherein the stored information includes data for various onesof the plurality of objects that is indicative of attribute values forone or more of a plurality of attributes of the plurality of objects;receiving a user-defined attribute for the namespace and a particularattribute value for the user-defined attribute for an object included inthe namespace; adding the user-defined attribute to the namespace;assigning the particular attribute value to an object in the namespace;and in response to receiving a query that specifies the particularattribute value, transmitting information usable to access one or moreobjects in the namespace, including the object.
 20. The system of claim19, wherein the user-defined attribute is a media type attribute andwherein the particular attribute value specifies that the object is anaudio object.
 21. The system of claim 19, wherein the operations furthercomprise: receiving a second user-defined attribute for the namespace;and assigning one or more second attribute values for the seconduser-defined attribute to one or more objects in the namespace.
 22. Thesystem of claim 19, wherein the operations further comprise: assigning asecond attribute value for the user-defined attribute to a second objectin the namespace, wherein the second attribute value is a differentattribute value than the particular attribute value.
 23. The system ofclaim 19, wherein the operations further comprise: caching informationindicating a set of attributes assigned to the object; in response todetermining that the query specifies an attribute value for theuser-defined attribute, determining, based on the cached information,whether the user-defined attribute is assigned to the object; andproceeding to determine whether the object has the particular attributevalue in response to determining that the user-defined attribute isassigned to the object.
 24. The system of claim 19, wherein the userdefined wherein the query indicates an organization of query results;and wherein the information usable to access one or more objects in thenamespace is organized using a hierarchy of attributes, wherein theuser-defined attribute is in a position in the hierarchy of attributesthat is indicated by the query.